#include <iostream>
#include<stdlib.h>
using namespace std;

//友元
//
//class Data
//{
//public:
//    friend void Print(Data&d1);//只可以在类中使用
//    Data()
//    {
//        cout<<"Data()"<<endl;
//    }
//private:
//    int _day=10;
//};
//void Print(Data&d1)
//{
//  cout<<d1._day;
//}
//int main()
//{
//    Data d1;
//
//    Print(d1);
//
//    //友元就是突破封装的一种方式有了他类基本随便访问
//    //但这就本末倒置了，所以一般可以不用就不用，宁愿在类中实现也不用友元
//}


//类中定义类
//class Data1
//{
//public:
//    Data1()
//    {
//        cout<<"Data1"<<endl;
//    }
//    class Data2
//    {
//    public:
//        Data2()
//        {
//            cout<<"Data2"<<endl;
//        }
//        void Print(const Data1&d1)
//        {
//            cout<<_day;
//        }
//        int h;
//    };
//
//
//private:
//  static int _day;
//};
// int Data1:: _day=20;
//
//
//
//int main()
//{
//    Data1 d1;
//    cout<<sizeof(d1);
//}

//----------------------------------------------------------------//



//new malloc free delete
class Data
{
public:
    Data()
    {
        cout<<"Data()"<<endl;
    }
    ~Data()
    {
        cout<<"~Data()"<<endl;
    }

private:
};


int main()
{
    //内置类型
//    int *a=(int *)malloc(sizeof(int));
//    *a=10;
//    cout<<*a;
//    free(a);
//
//    int *b=new int;
//    *b=20;
//    cout<<*b;


//    Data* a1=(Data*)malloc(sizeof(Data));
//    free(a1);
//
//
//    Data* b1=new Data;
//    delete(b1);

//    int * a1=(int *)malloc(1024*1024*1024);
//    if(a1==NULL)
//    {
//        cout<<"a1 malloc fail"<<endl;
//    }

//    try
//    {
//        int *b1=new int[1024*1024*1024*2];
//        printf("new success");
//    }
//    catch (const exception&e)
//    {
//        cout<<e.what()<<endl;
//    }




Data*b1=(Data*)operator new(sizeof(Data));




      //相同
     //1.他们对于内置类型的处理是一样的不初始化
    //2.本质上是相同的调用的都是malloc，
    //3。但是new调用了operator new，但是他其实就是封装了malloc罢了

    //不同
    //2.但是对于自定义类型将会初始化
    //3. 处理错误的方式也不同,new开辟fail会抛一个异常，不接收会崩

    operator delete(b1);
}